• Subsumes Noop coldstore for splitstore #6458 (see PubSub Booster network integration #6418)
• Cherry-picks and subsumes Splitstore optimizations #5808

This PR enhances the logic in splitstore:

• Dead experimental code related to full compaction with gc is removed.
• We change the compaction range model to be right to left, so that multiple compactions that would happen after a lengthy sync are coalesced to one.
• We add logic to implement a noop coldstore so that we can run with fixed hardware requirements (modulo chain headers).
• We introduce our own state walking code to replace WalkSnapshot so as to improve performance, be scalable regardless of height, and also include all reachable state objects to account for potential misses.
• We walk the entire range from current ts to compaction boundary during compaction, so as to correctly react to sync gaps; previously we only walked at the boundary, which could result in premature purging in the case of sync gaps.
• We kill the tracking store. The base utility of the tracking store was to protect new writes during compaction, but tracking the writeEpoch. However, this breaks down (very) badly in reality as vm flushing (see vm.Copy) intelligently tries to avoid duplicate writes and occurs checks with Has.
• We fix a race between purge and objects being considered live by higher layers that would lead to a fatal error with a noop coldstore and result in live state objects being prematurely moved to cold storage otherwise. The issue is that between marking and purge an object might be recreated and checked for existence in the blockstore by the vm with Has. If the object was not marked as rechable and the access happened before purge, then it would result in a miss. We fix this by making the compaction transactional, in that during compaction accesses to objects are recorded so as to not purge live objects.
• We treat Has as an implicit (recursive) write to account for vm behaviour on Copy.
• We keep all headers in the hotstore as it is not currently safe to discard them.

Follow up:

• We need a way to mark network initiated blockstore accesses such as not to consider these objects live for compaction purposes and blow the cache. This will need a blockstore interface change to accept options.
• We need a way for the vm to explicitly tell us whether to treat a Has request as an implicit write. We currently do it for every invocation (which is safe for now, given our usage patterns), but this is brittle; this will similarly require a blockstore interface change to accept options.
• We need to identify how many headers we need to keep in the case of fixed hardware requirements (e.g. boosters), so as not to slowly grow the hotstore with chain headers.